package pck_tramitedocu.pck_src.pck_dao;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import net.sf.jasperreports.engine.JasperPrint;
import org.springframework.dao.DataAccessException;
import pck_tramitedocu.pck_src.pck_pojos.Cls_Bandeja_Documento;
import pck_tramitedocu.pck_src.pck_pojos.Cls_Bandeja_destinatarios_derivacion;
import pck_tramitedocu.pck_src.pck_pojos.Cls_Borrador;
import pck_tramitedocu.pck_src.pck_pojos.Cls_Documento_Historial;
import pck_tramitedocu.pck_src.pck_pojos.Cls_Notificaciones;
import pck_tramitedocu.pck_src.pck_pojos.Cls_Visto;
import pck_tramitedocu.pck_src.pck_pojos.Cls_documento;
import pck_tramitedocu.pck_src.pck_pojos.TramiteDocuException;
import pck_tramitedocu.pck_src.pck_utiles.Cls_Parametros;
import pck_tramitedocu.pck_src.pck_utiles.cls_utilitarios;

public class Cls_dao_documento extends Cls_dao_Mybatis_Jdbc_Connection implements Itf_dao_documento {

    public String agregarBorradorDao(Map<String, Object> mp_documento) throws TramiteDocuException {
        Cls_Borrador borradorBean = (Cls_Borrador) mp_documento.get(Cls_Parametros.Objeto_BORRADOR);
        Connection cn = null;
        CallableStatement st = null;
        String resultado = "";
        try {
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareCall("" + mp_documento.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
            st.registerOutParameter(1, 12);
            st.setString(2, borradorBean.getTipo_documento());
            st.setString(3, cls_utilitarios.utf8_decode(borradorBean.getQuien_elabora()));
            st.setString(4, cls_utilitarios.utf8_decode(borradorBean.getMensaje_quien_elabora()));
            st.setString(5, cls_utilitarios.utf8_decode(borradorBean.getDestinatariosString()));
            st.setString(6, cls_utilitarios.utf8_decode(borradorBean.getAsunto()));
            st.setString(7, cls_utilitarios.utf8_decode(borradorBean.getCuerpo()));
            st.setString(8, cls_utilitarios.utf8_decode(borradorBean.getReferenciaString()));
            st.setString(9, cls_utilitarios.utf8_decode(borradorBean.getCon_copia_usuariosString()));
            st.setString(10, cls_utilitarios.utf8_decode(borradorBean.getUsuario_logueado()));
            st.setString(11, cls_utilitarios.utf8_decode(borradorBean.getFirma()));
            st.execute();
            resultado = st.getString(1);
        } catch (SQLException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        } finally {
            try {
                st.close();
                cn.close();
            } catch (SQLException ex) {
            }
        }
        return resultado;
    }

    public String agregarDocumentoDao(Map<String, Object> mp_documento) throws TramiteDocuException {
        Cls_documento documento = (Cls_documento) mp_documento.get(Cls_Parametros.Objeto_DOCUMENTO);

        Connection cn = null;
        CallableStatement st = null;
        try {
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareCall("" + mp_documento.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
            st.registerOutParameter(1, 12);
            st.setString(2, documento.getTipo_documento());
            st.setLong(3, documento.getNumero_documento());
            st.setString(4, documento.getAnhio() == null ? " " : documento.getAnhio());

            if (cls_utilitarios.areStringEquals(documento.getTipo_documento(), Cls_Parametros.TIPO_DOCUMENTO_RESOLUCION_GERENCIA_GENERAL)
                    || cls_utilitarios.areStringEquals(documento.getTipo_documento(), Cls_Parametros.TIPO_DOCUMENTO_RESOLUCION_GERENCIA_ADM)
                    || cls_utilitarios.areStringEquals(documento.getTipo_documento(), Cls_Parametros.TIPO_DOCUMENTO_RESOLUCION_GERENCIA_COMERCIAL)) {

                st.setString(5, cls_utilitarios.utf8_decode(documento.getAsunto()));
                st.setString(6, cls_utilitarios.utf8_decode(documento.getCuerpo()));
                st.setString(7, cls_utilitarios.utf8_decode(documento.getArticulosString()));
                st.setString(8, cls_utilitarios.utf8_decode(documento.getFirma()));
                st.setString(9, documento.getCodigo_directivaString());
                st.setString(10, documento.getUsuario_logueado());
                st.setBoolean(11, documento.isIsProyectado());
                st.setString(12, documento.getCon_copia_usuariosString());
                if (mp_documento.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP).toString().equalsIgnoreCase(Cls_Parametros.SP_Funcion_INSERTAR_DOCUMENTO_RESOLUCUION)) {
                    st.setString(13, documento.getTipo_proyeccion());
                }
            } else {
                st.setString(5, cls_utilitarios.utf8_decode(documento.getAsunto()));
                st.setString(6, cls_utilitarios.utf8_decode(documento.getCuerpo()));
                st.setString(7, cls_utilitarios.utf8_decode(documento.getDestinatariosString()));
                st.setString(8, cls_utilitarios.utf8_decode(documento.getReferenciaString()));
                st.setInt(9, Integer.parseInt(documento.getFecha_respuesta()));
                st.setString(10, documento.getCon_copia_usuariosString());
                st.setString(11, cls_utilitarios.utf8_decode(documento.getFirma()));
                st.setString(12, documento.getTipo_documento().compareToIgnoreCase("999") == 0 ? cls_utilitarios.utf8_decode(documento.getCabecera()) : documento.getCodigo_directivaString());

                st.setBoolean(13, documento.isIsProyectado());
                st.setString(14, documento.getUsuario_logueado());
                st.setString(15, documento.getTipo_documento().compareToIgnoreCase("999") == 0 ? documento.getCodigo_empresa() : "");

                st.setString(16, documento.getCodigo_directiva_pertenece());
                st.setString(17, documento.getPersona_emite_documento());
                st.setString(18, documento.getTipo_proyeccion());
                st.setString(19, "");
            }
            st.execute();
            return st.getString(1);
        } catch (SQLException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        } finally {
            try {
                st.close();
                cn.close();
            } catch (SQLException ex) {
            }
        }
    }

    public String actualizarBandejaDocumentoDao(Map<String, String> map) throws TramiteDocuException {
        Connection cn = null;
        CallableStatement st = null;
        String resultado = "";
        try {
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareCall("" + (String) map.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
            st.registerOutParameter(1, 12);
            st.setString(2, (String) map.get("mp_cod_format"));
            st.setString(3, cls_utilitarios.utf8_decode((String) map.get(Cls_Parametros.Map_TRABAJADOR_DATA)));
            st.execute();
            resultado = st.getString(1);
        } catch (SQLException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        } finally {
            try {
                st.close();
                cn.close();
            } catch (SQLException ex) {
                Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return resultado;
    }

    public String darPermisosImprimirDao(Map<String, String> map) throws TramiteDocuException {
        Connection cn = null;
        CallableStatement st = null;
        String resultado = "";
        try {
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareCall("" + (String) map.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
            st.registerOutParameter(1, 12);
            st.setString(2, (String) map.get(Cls_Parametros.Map_TIPO_DOCUMENTO));
            st.setInt(3, Integer.parseInt((String) map.get(Cls_Parametros.Map_NUMERO_DOCUMENTO)));
            st.setString(4, cls_utilitarios.utf8_decode((String) map.get(Cls_Parametros.Map_ANHIO_DOCUMENTO)));
            st.setString(5, cls_utilitarios.utf8_decode((String) map.get(Cls_Parametros.Map_TRABAJADOR_ORIGEN)));
            st.setString(6, cls_utilitarios.utf8_decode((String) map.get(Cls_Parametros.Map_TRABAJADOR_DESTINO)));
            st.setString(7, cls_utilitarios.utf8_decode((String) map.get("param_observacion_imp")));
            st.execute();
            resultado = st.getString(1);
        } catch (SQLException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        } finally {
            try {
                st.close();
                cn.close();
            } catch (SQLException ex) {
            }
        }
        return resultado;
    }

    public String actualizarDocumentoVistoDao(Map<String, String> map) throws TramiteDocuException {
        Connection cn = null;
        CallableStatement st = null;
        String resultado = "";
        try {
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareCall("" + (String) map.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
            st.registerOutParameter(1, 12);
            st.setString(2, (String) map.get(Cls_Parametros.Map_TIPO_DOCUMENTO));
            st.setInt(3, Integer.parseInt((String) map.get(Cls_Parametros.Map_NUMERO_DOCUMENTO)));
            st.setString(4, (String) map.get(Cls_Parametros.Map_ANHIO_DOCUMENTO));
            st.setString(5, cls_utilitarios.utf8_decode((String) map.get("tipo_docu_cabe")));
            st.execute();
            resultado = st.getString(1);
        } catch (SQLException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        } finally {
            try {
                st.close();
                cn.close();
            } catch (SQLException ex) {
            }
        }
        return resultado;
    }

    public String delegarDocumentoDesdeBandejaDao(Map<String, String> map) throws TramiteDocuException {
        Connection cn = null;
        CallableStatement st = null;
        String resultado = "";
        try {
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareCall("" + (String) map.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
            st.registerOutParameter(1, 12);
            st.setString(2, (String) map.get(Cls_Parametros.Map_NUMERO_DOCUMENTO));
            st.setString(3, cls_utilitarios.utf8_decode((String) map.get("mp_destinatarios")));
            st.setString(4, cls_utilitarios.utf8_decode((String) map.get(Cls_Parametros.Map_TRABAJADOR_DATA)));
            st.setString(5, cls_utilitarios.utf8_decode((String) map.get("mp_cod_obs")));
            st.execute();
            resultado = st.getString(1);
        } catch (SQLException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        } finally {
            try {
                st.close();
                cn.close();
            } catch (SQLException ex) {
            }
        }
        return resultado;
    }

    public String dipararDocumentoDesdeBandejaParaVistoDao(Map<String, String> map) throws TramiteDocuException {
        Connection cn = null;
        CallableStatement st = null;
        String resultado = "";
        try {
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareCall("" + (String) map.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
            st.registerOutParameter(1, 12);
            st.setString(2, (String) map.get(Cls_Parametros.Map_TIPO_DOCUMENTO));
            st.setLong(3, Long.parseLong("" + map.get(Cls_Parametros.Map_NUMERO_DOCUMENTO)));
            st.setString(4, (String) map.get(Cls_Parametros.Map_ANHIO_DOCUMENTO));
            st.setString(5, cls_utilitarios.utf8_decode((String) map.get(Cls_Parametros.Map_TRABAJADOR_DATA)));
            st.setString(6, (String) map.get(Cls_Parametros.Map_PARAMETRO_APROBAR));
            st.execute();
            resultado = st.getString(1);
        } catch (SQLException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        } finally {
            try {
                st.close();
                cn.close();
            } catch (SQLException ex) {
            }
        }
        return resultado;
    }

    public String darVistoDocumentoDesdeBandejaParaRespuestaDao(Map<String, String> map) throws TramiteDocuException {
        Connection cn = null;
        CallableStatement st = null;
        String resultado = "";
        try {
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareCall("" + (String) map.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
            st.registerOutParameter(1, 12);
            st.setString(2, (String) map.get(Cls_Parametros.Map_TIPO_DOCUMENTO));
            st.setInt(3, Integer.parseInt((String) map.get(Cls_Parametros.Map_NUMERO_DOCUMENTO)));
            st.setString(4, (String) map.get(Cls_Parametros.Map_ANHIO_DOCUMENTO));
            st.setString(5, cls_utilitarios.utf8_decode((String) map.get(Cls_Parametros.Map_TRABAJADOR_DATA)));
            st.setString(6, cls_utilitarios.utf8_decode((String) map.get(Cls_Parametros.Map_ASUNTO)));
            st.execute();
            resultado = st.getString(1);
        } catch (SQLException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        } finally {
            try {
                st.close();
                cn.close();
            } catch (SQLException ex) {
            }
        }
        return resultado;
    }

    public String agregarHistorialDocumentoDao(Map<String, String> map) throws TramiteDocuException {
        Connection cn = null;
        CallableStatement st = null;
        String resultado = "";
        try {
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareCall("" + (String) map.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
            st.registerOutParameter(1, 12);
            st.setString(2, (String) map.get(Cls_Parametros.Map_TIPO_DOCUMENTO));
            st.setInt(3, Integer.parseInt((String) map.get(Cls_Parametros.Map_NUMERO_DOCUMENTO)));
            st.setString(4, (String) map.get(Cls_Parametros.Map_ANHIO_DOCUMENTO));
            st.setString(5, cls_utilitarios.utf8_decode((String) map.get(Cls_Parametros.Map_TRABAJADOR_ORIGEN)));
            st.setString(6, cls_utilitarios.utf8_decode((String) map.get(Cls_Parametros.Map_TRABAJADOR_DESTINO)));
            st.setString(7, cls_utilitarios.utf8_decode((String) map.get(Cls_Parametros.Map_ASUNTO)));
            st.execute();
            resultado = st.getString(1);
        } catch (SQLException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        } finally {
            try {
                st.close();
                cn.close();
            } catch (SQLException ex) {
            }
        }
        return resultado;
    }

    public boolean actualizarDocumentoDao(Cls_documento alumno) {
        return true;
    }

    public boolean eliminarDocumentoDao(String codigo) {
        return true;
    }

    public Cls_documento obtenerDocumentoConTodaInformacionDao(Map<String, String> map) throws TramiteDocuException {
        String tipo_documento = "" + (String) map.get(Cls_Parametros.Map_TIPO_DOCUMENTO);
        String consulta_OR_resolucion = "";
        if (tipo_documento.compareToIgnoreCase("001") == 0) {
            consulta_OR_resolucion = Cls_Parametros.FuncionIbt_TramiteDocumentario_DOCUMENTO_RESOLUCION_OBTENER_TODA_INFORMACION;
        } else {
            consulta_OR_resolucion = Cls_Parametros.FuncionIbt_TramiteDocumentario_DOCUMENTO_OBTENER_TODA_INFORMACION;
        }
        Cls_documento documento = null;
        try {
            documento = (Cls_documento) getSqlMapClientTemplate().queryForObject(consulta_OR_resolucion, map);
        } catch (DataAccessException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        }
        return documento;
    }

    public ArrayList<Cls_documento> obtenerTodosDocumentoDao(Map<String, String> map) {
        try {
            return (ArrayList) getSqlMapClientTemplate().queryForList(Cls_Parametros.FuncionIbt_TramiteDocumentario_DOCUMENTO_LISTAR, map, (Integer.parseInt((String) map.get("page")) - 1) * Integer.parseInt((String) map.get("rp")), Integer.parseInt((String) map.get("rp")));

        } catch (DataAccessException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }

    public int obtenerCantidadDeRegistrosDao(Map<String, String> map) {
        try {
            return ((Integer) getSqlMapClientTemplate().queryForObject("MySpacesNS-documento.obtenerCantidadDocumentosIbt", map)).intValue();
        } catch (DataAccessException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
        }
        return 0;
    }

    public JasperPrint obtenerDocumentoPrintDao(Map<String, String> map) {
        return null;
    }

    public Object obtenerTodosDocumentoPersonalesDao(Map<String, String> map) {
        if (((String) map.get(Cls_Parametros.Request_ARRAY_SELECCIONADO)).compareToIgnoreCase("A") == 0) {
            try {
                ArrayList array = cls_utilitarios.generarArrayDesdeString((String) map.get("dsaddgfsdgdfhfddasg5wdfsdfdfdsasada"));
                map.put("areas", ((String) map.get(Cls_Parametros.Request_AREAS_JERARQUIA)).replaceAll(";", ","));
                return (ArrayList) getSqlMapClientTemplate().queryForList(Cls_Parametros.FuncionIbt_TramiteDocumentario_DOCUMENTO_OBTENER_PERSONALES_AREA, array,
                        (Integer.parseInt((String) map.get("page")) - 1) * Integer.parseInt((String) map.get("rp")),
                        Integer.parseInt((String) map.get("rp")));
            } catch (DataAccessException ex) {
                Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            }
        } else {
            try {
                return (ArrayList) getSqlMapClientTemplate().queryForList(Cls_Parametros.FuncionIbt_TramiteDocumentario_DOCUMENTO_OBTENER_PERSONALES,
                        map, (Integer.parseInt((String) map.get("page")) - 1) * Integer.parseInt((String) map.get("rp")),
                        Integer.parseInt((String) map.get("rp")));
            } catch (DataAccessException ex) {
                Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return null;
    }

    public int obtenerCantidadDeDocumentosPersonalesDao(Map<String, String> map) {
        if (((String) map.get("array_selected")).compareToIgnoreCase("A") == 0) {
            try {
                ArrayList array = cls_utilitarios.generarArrayDesdeString((String) map.get("dsaddgfsdgdfhfddasg5wdfsdfdfdsasada"));
                int total = ((Integer) getSqlMapClientTemplate().queryForObject("MySpacesNS-documento.obtenerCantidadDocumentosPersonalesAreaIbt", array)).intValue();
                return total;
            } catch (DataAccessException ex) {
                Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            }
        } else {
            try {
                int total = ((Integer) getSqlMapClientTemplate().queryForObject("MySpacesNS-documento.obtenerCantidadDocumentosPersonalesIbt", map)).intValue();
                return total;
            } catch (DataAccessException ex) {
                Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return 0;
    }

    public Cls_Bandeja_Documento obtenerDocumentoPersonalBandejaDao(Map<String, String> map) throws TramiteDocuException {
        Cls_Bandeja_Documento documento = null;
        try {
            documento = (Cls_Bandeja_Documento) getSqlMapClientTemplate().queryForObject("MySpacesNS-documento.obtenerDocumentoPersonalIbt", map);
        } catch (DataAccessException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        }
        return documento;
    }

    public boolean necesitaGenerarFlashDao(Map<String, String> map) {
        String opcion_realizar = "";
        boolean opcion = new Boolean((String) map.get("function_flash")).booleanValue();

        if (opcion) {
            Connection cn = null;
            CallableStatement st = null;
            String resultado = "";
            try {
                cn = getDataSourceSistema().getConnection();
                st = cn.prepareCall("" + (String) map.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
                st.registerOutParameter(1, 12);
                st.setString(2, (String) map.get(Cls_Parametros.Map_NUMERO_DOCUMENTO));
                st.execute();
                resultado = st.getString(1);
            } catch (Exception ex) {
                Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            } finally {
                try {
                    st.close();
                    cn.close();
                } catch (SQLException ex) {
                    Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
            return true;
        }
        try {
            return ((Boolean) getSqlMapClientTemplate().queryForObject("MySpacesNS-documento.generaFlasIbt", map)).booleanValue();
        } catch (DataAccessException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }

    public String mantenimientoExtensionDao(Map<String, Object> mp_empresa) {
        String extensiones = "" + mp_empresa.get("object_extension");
        String codigo_documento = "" + mp_empresa.get("mp_cod_format");
        String[] codigo_documento_array = codigo_documento.split("-");
        Connection cn = null;
        String retorno = "";
        try {
            cn = getDataSourceSistema().getConnection();
            CallableStatement st = cn.prepareCall("" + mp_empresa.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
            st.registerOutParameter(1, 12);
            st.setString(2, codigo_documento_array[0]);
            st.setInt(3, Integer.parseInt(codigo_documento_array[1]));
            st.setString(4, codigo_documento_array[2]);
            st.setString(5, extensiones);
            st.execute();
            retorno = st.getString(1);
            st.close();
            cn.close();
        } catch (SQLException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
        }
        return retorno;
    }

    public ArrayList<Cls_Documento_Historial> obtenerHistorialDocumentoDao(Map<String, String> parametros) throws TramiteDocuException {
        try {
            return (ArrayList) getSqlMapClientTemplate().queryForList(Cls_Parametros.FuncionIbt_TramiteDocumentario_OBTIENE_DOCUMENTO_HISTORIAL,
                    parametros);
        } catch (DataAccessException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        }
    }

    public int obtenerCantidadHistorialDao(Map<String, String> map) throws TramiteDocuException {
        try {
            return ((Integer) getSqlMapClientTemplate().queryForObject("MySpacesNS-documento.obtenerCantidadHistorialIbt", map)).intValue();
        } catch (DataAccessException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        }
    }

    public ArrayList<Cls_Visto> obtenerVistoDocumentoDao(Map<String, Object> documento) throws TramiteDocuException {
        try {
            return (ArrayList) getSqlMapClientTemplate().queryForList("MySpacesNS-documento.obtenerDocumentoVistoIbt", documento);
        } catch (DataAccessException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        }
    }

    public String cerrarDocumentoDao(Map<String, Object> mp_empresa) {
        String trabajador_data = "" + mp_empresa.get(Cls_Parametros.Map_TRABAJADOR_DATA);
        Connection cn = null;
        CallableStatement st = null;
        String resultado = "";
        try {
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareCall("" + mp_empresa.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
            st.registerOutParameter(1, 12);
            st.setLong(3, Long.parseLong("" + mp_empresa.get(Cls_Parametros.Map_NUMERO_DOCUMENTO)));
            st.setString(2, "" + mp_empresa.get(Cls_Parametros.Map_TIPO_DOCUMENTO));
            st.setString(4, "" + mp_empresa.get(Cls_Parametros.Map_ANHIO_DOCUMENTO));
            st.setString(5, cls_utilitarios.utf8_decode(trabajador_data));
            st.execute();
            resultado = st.getString(1);
        } catch (Exception ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                st.close();
                cn.close();
            } catch (SQLException ex) {
                Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return resultado;
    }

    public int puedeImprimirDocumentoDao(Map<String, String> map) {
        Connection cn = null;
        CallableStatement st = null;
        int resultado = 0;
        try {
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareCall("{?=call fun_documento_imprimir(?,?,?,?)}");
            st.registerOutParameter(1, 4);
            st.setString(2, (String) map.get(Cls_Parametros.Map_TIPO_DOCUMENTO));
            st.setInt(3, Integer.parseInt((String) map.get(Cls_Parametros.Map_NUMERO_DOCUMENTO)));
            st.setString(4, (String) map.get(Cls_Parametros.Map_ANHIO_DOCUMENTO));
            st.setString(5, (String) map.get("mp_dni"));

            st.execute();
            resultado = st.getInt(1);
        } catch (Exception ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                st.close();
                cn.close();
            } catch (SQLException ex) {
                Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return resultado;
    }

    public String AsignarCorrelativoADocumentoDao(Map<String, Object> mp_empresa) {
        Connection cn = null;
        CallableStatement st = null;
        String resultado = "";
        try {
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareCall("" + (String) mp_empresa.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
            st.registerOutParameter(1, 12);
            st.setInt(2, Integer.parseInt((String) mp_empresa.get(Cls_Parametros.Map_NUMERO_DOCUMENTO)));
            st.setString(3, (String) mp_empresa.get(Cls_Parametros.Map_TIPO_DOCUMENTO));
            st.setString(4, (String) mp_empresa.get(Cls_Parametros.Map_ANHIO_DOCUMENTO));
            st.execute();
            resultado = st.getString(1);
        } catch (Exception ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                st.close();
                cn.close();
            } catch (SQLException ex) {
                Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return resultado;
    }

    public String aprobarDocumentoDao(Map<String, Object> mp_empresa) throws TramiteDocuException {
        String trabajador_data = (String) mp_empresa.get(Cls_Parametros.Map_TRABAJADOR_DATA);
        Connection cn = null;
        CallableStatement st = null;
        String resultado = "";
        try {
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareCall("" + (String) mp_empresa.get(Cls_Parametros.Funcion_REALIZAR_PROCEDIMIENTO_MAP));
            st.registerOutParameter(1, 12);
            st.setString(2, (String) mp_empresa.get(Cls_Parametros.Map_TIPO_DOCUMENTO));
            st.setInt(3, Integer.parseInt((String) mp_empresa.get(Cls_Parametros.Map_NUMERO_DOCUMENTO)));
            st.setString(4, (String) mp_empresa.get(Cls_Parametros.Map_ANHIO_DOCUMENTO));
            st.setString(5, cls_utilitarios.utf8_decode(trabajador_data));
            st.setString(6, (String) mp_empresa.get(Cls_Parametros.Map_PARAMETRO_APROBAR));
            st.execute();
            resultado = st.getString(1);
        } catch (SQLException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        } finally {
            try {
                st.close();
                cn.close();
            } catch (SQLException ex) {
            }
        }
        return resultado;
    }

    public ArrayList<Cls_Notificaciones> obtenerNotificacionesDao(Map<String, String> map) {
        ArrayList notificaciones = null;
        try {
            notificaciones = (ArrayList) getSqlMapClientTemplate().queryForList("MySpacesNS-trabajador.obtenerNotificaciones", map);
        } catch (DataAccessException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
        }
        return notificaciones;
    }

    public ArrayList<Cls_Bandeja_destinatarios_derivacion> obtenerDestinatariosDeDerivacionDao(Map<String, String> map) throws TramiteDocuException {
        ArrayList destinatarios = null;
        try {
            destinatarios = (ArrayList) getSqlMapClientTemplate().queryForList("MySpacesNS-documento.destinatariosDeBandejaDerivados", map);
        } catch (DataAccessException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        }
        return destinatarios;
    }

    public String eliminarPositBorradorDeBandejaDao(Map<String, Object> map) {
        String retorno = "";
        try {
            this.getSqlMapClientTemplate().update(Cls_Parametros.FuncionIbt_TramiteDocumentario_ELIMINAR_POSIT, map);
            retorno = "SE ELIMINO CORRECTAMENTE";
        } catch (DataAccessException ex) {
            retorno = "ERROR AL ELIMINAR POSIT";
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
        }
        return retorno;
    }

    public ArrayList<String> obtenerAños() {
        ArrayList Años = new ArrayList<String>();
        try {
            Connection cn = null;
            PreparedStatement st = null;
            cn = getDataSourceSistema().getConnection();
            st = cn.prepareStatement("SELECT anhio_docu FROM tb_documento GROUP BY anhio_docu ORDER BY anhio_docu DESC");
            ResultSet rs = st.executeQuery();
            while (rs.next()) {
                String año = rs.getString("anhio_docu");
                Años.add(año);
            }
            cn.close();
            st.close();
        } catch (SQLException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
        }
        return Años;
    }

    public Cls_documento obtenerCabeceraHistorialDocumentoDao(Map<String, String> paramMap) throws TramiteDocuException {
          Cls_documento historialDocumento = null;
        try {
            historialDocumento = (Cls_documento) getSqlMapClientTemplate().queryForObject("MySpacesNS-documento.obtenerCabeceraHistorial",paramMap);
        } catch (DataAccessException ex) {
            Logger.getLogger(Cls_dao_documento.class.getName()).log(Level.SEVERE, null, ex);
            throw new TramiteDocuException(ex.getClass().getSimpleName());
        }
        return historialDocumento;
    }
}
